nightfury7 / universalbasics.js

/** global: Buffer */

/*! ARRAY UTILS */

var arrayFuncs = {

		var list = this;

		var total = 0;

		for (var a = 0, al = list.length;a<al;a++){

			if (not) {

				if (list[a] != value) {

					total++;

				}

			}else {

				if (list[a] == value) {

					total++;

				}

			}

		}

		return total;

	},

	or: function(list2){

		var list = this;

		if (list.exists()) {

			return list;

		}

		return list2;

	},

	part: function(start, end){

		var list = this;

		// quickly exit if no items or no results possible

		if (list == null || list.length === 0 || start > end || start >= list.length) {

			return [];

		}

		// just get the part we need

		return list.slice(start, end + 1);

	},

	swap: function(slot1, slot2){

		var list = this;

		var temp = list[slot2];

		list[slot2] = list[slot1];

		list[slot1] = temp;

	},

	add: function(item){

		var list = this;

		list.push(item);

		return list.length - 1;

	},

	addToStart: function(item){

		var list = this;

		list.unshift(item);

		return 0;

	},

	/** return false if item exists, true if item does not */

	addOnce: function(value){

		var list = this;

		// return false if item exists

		if (list.indexOf(value) > -1) {

			return false;

		}

		// add if not found

		list.push(value);

		return true;

	},

	addArray: function(toAdd, addAtSlot = -1, modifyMain = true){

		var list = this;

		if (toAdd != null && toAdd.length > 0) {

			if (!modifyMain) {

				list = list.concat(); /// shallow clone

			}

			// set length first so allocates memory (maybe?)

			var origLen = list.length;

			if (addAtSlot === -1){

				list.length += toAdd.length;

			}

			// set all slots

			var next = addAtSlot === -1 ? origLen : addAtSlot;

			for (var a = 0, al = toAdd.length;a<al;a++, next++){

				list[next] = toAdd[a];

			}

		}

		return list;

	},

	/** adds the given value many times */

	addManyTimes: function(val, times){

		var list = this;

		if (times <= 0) {

			return list;

		}

		var n = list.length;

		for (var t = 0;t<times;t++){

			list[n++] = val;

		}

		return list;

	},

	addRange: function(toAdd, startSlot, endSlot){

		var list = this;

		// exit if no work

		if (endSlot < startSlot) {

			return;

		}

		// per wanted slot of the `add` array

		startSlot = startSlot.limitToArray(toAdd);

		endSlot = endSlot.limitToArray(toAdd);

		for (var s = startSlot;s <= endSlot;s++){

			// add into `main` array

			list.push(toAdd[s]);

		}

	},

	/** returns final index of added item, or index of already existing item */

	findOrAdd: function(value){

		var list = this;

		// return index of item if exists

		var i = list.indexOf(value);

		if (i > -1) {

			return i;

		}

		// add if not found

		i = list.length;

		list[i] = value;

		return i;

	},

	insertOne: function(item, slot){

		var list = this;

		// adds one slot at the given point

		// modifies the main array

		list.splice(slot, 0, item);

	},

	/** if slot = -1 or outside the array, the item is added to the END of the array.

	 * Otherwise the item is added at the given slot. */

	insertOneOrAdd: function(item, slot){

		var list = this;

		// adds one slot at the given point

		// modifies the main array

		if (slot < 0 || slot >= list.length) {

			list.push(item);

			return list.length - 1;

		}

		list.splice(slot, 0, item);

		return slot;

	},

	insertArray: function(newItems, slot, returnNew = true){

		var list = this;

		// adds many slots at the given point

		// returns a new array

		if(returnNew){

			return list.slice(0, slot).concat(newItems).concat(list.slice(slot));

		}

		// adds many slots at the given point

		// modifies the main array

		for (var a = 0, al = newItems.length;a<al;a++){

			list.splice(slot++, 0, newItems[a]);

		}

		return list;

	},

	insertArrayAfter: function(newItems, after){

		var list = this;

		if (list.isLast(after)) {

			list.addArray(newItems);

		} else {

			var i = list.indexOf(after);

			list.insertArray(i + 1, newItems);

		}

	},

	removeAndInsert: function(from, to){

		var list = this;

		// ensure slots within array

		var al = list.length;

		from = from.limitTo(0, al - 1);

		to = to.limitTo(0, al - 1);

		if (to < from) {

			var i1 = to;

			var i2 = from;

		}else {

			i1 = from;

			i2 = to;

		}

		// fill unaffected header

		var result = [];

		if(i1 > 0){

			for (var a = 0;a<i1;a++){

				result[a] = list[a];

			}

		}

		// fill "to"

		result[to] = list[from];

		// fill between from and to

		if(to < from){

			for (a = to + 1; a <= from; a++) {

				result[a] = list[a - 1];

			}

		}else {

			for (a = from; a < to; a++) {

				result[a] = list[a + 1];

			}

		}

		// fill unaffected footer

			result[a] = list[a];

		}

		return result;

	},

	/** replace a range of items with a given array */

	replaceRange: function(replaceStartSlot, replaceEndSlot, newItems, returnNew = true){

		var list = this;

		// simply remove a single item

		if (replaceStartSlot == replaceEndSlot && newItems.length === 0) {

			if (returnNew) {

				list = list.concat();

			}

			list.splice(replaceStartSlot, 1);

			return list;

		// simply replace a single item

		}else if (replaceStartSlot == replaceEndSlot && newItems.length === 1) {

			if (returnNew) {

				list = list.concat();

			}

			list[replaceStartSlot] = newItems[0];

			return list;

		}

		// alt method if returning a new array

		if(returnNew){

			return list.slice(0, replaceStartSlot).concat(newItems).concat(list.slice(replaceEndSlot + 1));

		}

		// remove many

		list.splice(replaceStartSlot, (replaceEndSlot - replaceStartSlot) + 1);

		// insert many

		var slot = replaceStartSlot;

		for (var a = 0, al = newItems.length;a<al;a++){

			list.splice(slot++, 0, newItems[a]);

		}

		return list;

	},

	splitAt: function(slot, includeSlot = false, includeInFirst = false){

		var list = this;

		if (includeSlot) {

			if (includeInFirst) {

				return [list.slice(0, slot + 1), list.slice(slot + 1)];

			}

			return [list.slice(0, slot), list.slice(slot)];

		}

		return [list.slice(0, slot), list.slice(slot+1)];

	},

	splitAtEvery: function(seperator){

		var list = this;

		var splits = [];

		var lastSlot = 0;

		for (var a = 0, al = list.length;a<al;a++){

			if (list[a] == seperator && a > lastSlot) {

				splits.push(list.slice(lastSlot, a));

				lastSlot = a + 1;

			}

		}

		return splits;

	},

	moveToTop: function(slot, returnNew = false){

		var list = this;

			// ALWAYS RETURNS NEW ARRAY

			// exit quickly if slot not in array

			var al = list.length;

			if (slot < 0 || slot >= al) {

				return list.concat();

			}

			// create new array with slot on top

			var newArr = [list[slot]];

			var n = 1;

			// add all other slots

			for (var a = 0;a<al;a++){

				if (a != slot) {

					newArr[n++] = list[a];

				}

			}

			return newArr;

		}

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array

		if (slot < 0 || slot >= al) {

		}

		// delete and re-add slot

		var val = list[slot];

		list.splice(slot, 1);

	},

	moveToBottom: function(slot, returnNew = false){

		var list = this;

			// ALWAYS RETURNS NEW ARRAY

			// exit quickly if slot not in array

			var al = list.length;

			if (slot < 0 || slot >= al) {

				return list.concat();

			}

			// create new array with slot on top

			var newArr = [];

			var n = 0;

			// add all other slots

			for (var a = 0;a<al;a++){

				if (a != slot) {

					newArr[n++] = list[a];

				}

			}

			// add slot to bottom

			return newArr;

		}

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array

		if (slot < 0 || slot >= al) {

		}

		// delete and re-add slot

		var val = list[slot];

		list.splice(slot, 1);

	},

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already at bottom

		var al = list.length;

		var slot = list.indexOf(item);

		if (slot < 0 || slot >= (al - 1)) {

			return false;

		}

		// move one down

		list.swap(slot, slot + 1);

		return true;

	},

	moveSlotUp: function(slot){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already on top

		var al = list.length;

		if (slot <= 0 || slot >= al) {

			return false;

		}

		// move one up

		list.swap(slot, slot - 1);

		return true;

	},

	moveSlotDown: function(slot){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already at bottom

		var al = list.length;

		if (slot < 0 || slot >= (al - 1)) {

			return false;

		}

		// move one down

		list.swap(slot, slot + 1);

		return true;

	},

	/** Move an item from the given list, to the start/end of the target list */

	moveToArray: function(item, toList, evenIfExists = false, addToEnd = true){

		var list = this;

		// remove from source list

		RemoveOne(list, item);

		// add to target list

		if (evenIfExists || toList.indexOf(item) === -1) {

			if (addToEnd) {

				toList.push(item);

			}else{

				toList.unshift(item);

			}

			return true;

		}

		return false;

	},

	/** Returns the nearest existing slot value in the array. Returns `ifNoSlots` if the array is empty. */

	within: function(slot, ifNoSlots = null){

		var list = this;

		// return null if array empty

		var len = list.length;

		if (len === 0) {

			return ifNoSlots;

		}

		// return first slot if index negative

		if (slot < 0) {

			return list[0];

		}

		// return last slot if index more than last slot

		if (slot >= len) {

			return list[len - 1];

		}

		// return given slot if within array

		return list[slot];

	},

	first: function(list){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return null;

		}

		return list[0];

	},

	firstExisting: function(slots, blankVal = null){

		var list = this;

		for (var s = 0, sl = slots.length;s<sl;s++){

			var val;

			if ((val = list[slots[s]]) != blankVal) {

				return val;

			}

		}

		return null;

	},

	last: function(list){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return null;

		}

		return list[len-1];

	},

	lastX: function(count){

		var list = this;

		var s = (0).max(list.length - count);

		return list.slice(s, list.length);

	},

	setFirst: function(value){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return;

		}

		list[0] = value;

	},

	setLast: function(value){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return;

		}

		list[len-1] = value;

	},

	random: function(list){

		var list = this;

		// return null if array empty

		if (list.length === 0) {

			return null;

		}

		// return random slot within array

		return list[parseInt(Math.random() * 1000000) % list.length];

	},

		var list = this;

		var out = [];

		if (!slots){

			return out;

		}

		for (var i = 0, il = slots.length;i<il;i++){

			if (val != null) {

				out.push(val);

			}

		}

		return out;

	},

		var list = this;

		var out = [];

		if (!slots){

			return out;

		}

		for (var i = 0, il = slots.length;i<il;i++){

			if (val != null || evenIfNull) {

				out[id] = val;

			}

		}

		return out;

	},

	/** Get the data of `list`, by searching `indexID` in `indexArr`, or return `defaultVal` if not found */

	getByMatchingArray: function(indexArr, indexID, defaultVal = null){

		var list = this;

		var slot = indexArr.indexOf(indexID);

		return slot === -1 ? defaultVal : list[slot];

	},

	/** Set the data of `list`, by searching `indexID` in `indexArr` */

	setByMatchingArray: function(indexArr, indexID, data){

		var list = this;

		var slot = indexArr.indexOf(indexID);

		if (slot === -1) {

			return false;

		}

		list[slot] = data;

		return true;

	},

	page: function(page, pageLength, invisibleRows = null){

		var list = this;

		// ensure page no. in limits

		var lastPage = Math.ceil(list.length / pageLength);

		page = page.limitTo(0, lastPage - 1);

		// get first/last row in page

		var pageStart = page*pageLength;/// 0-based - first row in page

		var pageEnd = (pageStart + pageLength) - 1;/// 0-based - last row in page

		// get on-page rows

		var visibleRows = list.part(pageStart, pageLength);

		// get off-page rows

		if (invisibleRows) {

			invisibleRows.addRange(list, 0, pageStart - 1);

			invisibleRows.addRange(list, pageEnd + 1, list.length - 1);

		}

		return visibleRows;

	},

	transpose: function() {

		var arr = this;

		var transposed = [];

		for (var r = 0; r < arr.length; r++) {

			for (var c = 0; c < arr[r].length; c++) {

				if (transposed[c] == null) {

					transposed[c] = [];

				}

				transposed[c][r] = arr[r][c];

			}

		}

		return transposed;

	},

	// fast sorting

	quickSort: function(ascending = true){

		var input = this;

		var len = input.length;

		if (len >= 2) {

			// sort in place

			input._quickSort(0, len - 1, 0);

			// flip if descending wanted

			if (!ascending) {

				input.reverse();

			}

		}

	},

	indexedQuickSort: function(ascending = true){

		var input = this;

		var len = input.length;

		if (len >= 2) {

			// indexed sort

			var index = UB.newArray(0, input.length);

			input._indexedQuickSort(index, 0, len - 1, 0);

			// flip if descending wanted

			if (!ascending) {

				index.reverse();

			}

			return index;

		}

		return null;

	},

	/** INTERNAL FUNCTION, do not use directly */

	_quickSort: function(left, right, d){

		var input = this;

		if (left >= right){

			return;

		}

		var j = right, i = left;

		var size = right - left;

		//var pivotPoint = input[uint((right>>>1) + (left>>>1))], t;

		var pivotPoint = input[((right>>>1) + (left>>>1)) >>> 0], t;

		do {

			if (size < 9) {

				pivotPoint = input[left];

				do {

					do {

						left++;

						if (input[left] < pivotPoint) {

							pivotPoint = input[left];

							do { // this section can be improved.

								input[left--] = input[left];

							} while (left > i && pivotPoint < input[left]);

							input[left] = pivotPoint;

						}

					} while (left < right);

					i++;

					left = i;

					pivotPoint = input[left];

				} while (i < right);

				return;

			}

			while (left < right) {

				if (input[right] > pivotPoint){

					do { right--; }

					while (input[right] > pivotPoint);

				}

				if (input[left] < pivotPoint){

					do { left++; }

					while (input[left] < pivotPoint);

				}

				if (left < right) {

					t = input[left];

					input[left] = input[right];

					input[right] = t;

					left++;

					right--;

				}

			}

			if (right) {

				if (left === right) {

					if (input[left] < pivotPoint){

						left++;

					}else if (input[right] > pivotPoint){

						right--;

					}

				}

				if (i < right) {

					input._quickSort(i, right, d + 1);

				}

			}

			left |= int(!left) & int(!right);

			if (j <= left){

				return;

			}

			i = left;

			right = j;

			//pivotPoint = input[uint((right >>> 1) + (left >>> 1))];

			pivotPoint = input[((right >>> 1) + (left >>> 1)) >>> 0];

			size = right - left;

			d++;

		} while (true);

	},

	/** INTERNAL FUNCTION, do not use directly */

	_indexedQuickSort: function(indexed, left, right, d){

		var input = this;

		if (left >= right){

			return;

		}

		// status

		var j;

		var i;

		var size = (j = right) - (i = left);

		//var pivotPoint = (input[uint((right>>>1) + (left>>>1))]);

		var pivotPoint = (input[((right>>>1) + (left>>>1)) >>> 0]);

		// temps

		var pivotIndex;

		var temp;

		var temp2;

		do {

			//{ part 1

			if (size < 9) {

				pivotPoint = input[left];

				do {

					do {

						left++;

						temp = input[left];

						if (temp < pivotPoint) {

							pivotIndex = indexed[left];

							pivotPoint = temp;

							do {

								// change vals

								input[left] = input[left - 1];

								// change indices

								indexed[left] = indexed[left - 1];

								left--;

							} while (left > i && pivotPoint < input[left]);

							// change vals

							input[left] = pivotPoint;

							// change indices

							indexed[left] = pivotIndex;

						}

					} while (left < right);

					i++;

					pivotPoint = input[left = i];

				} while (i < right);

				return;

			}

			//}

			//{ part 2

			while (left < right) {

				if (input[right] > pivotPoint) {

					do {

						right--;

					} while (input[right] > pivotPoint);

				}

				if (input[left] < pivotPoint) {

					do {

						left++;

					} while (input[left] < pivotPoint);

				}

				if (left < right) {

					// flip values

					temp = input[left];

					input[left] = input[right];

					input[right] = temp;

					// flip indices

					temp2 = indexed[left];

					indexed[left] = indexed[right];

					indexed[right] = temp2;

					left++;

					right--;

				}

			}

			//}

			//{ part 2

			if (right) {

				if (left === right) {

					if (input[left] < pivotPoint) {

						left++;

					}else if (input[right] > pivotPoint) {

						right--;

					}

				}

				if (i < right) {

					// recurse

					input._indexedQuickSort(indexed, i, right, d + 1);

				}

			}

			//}

			left |= int(!left) & int(!right);

			if (j <= left) {

				return;

			}

			i = left;

			right = j;

			//pivotPoint = input[uint((right >>> 1) + (left >>> 1))];

			pivotPoint = input[((right >>> 1) + (left >>> 1)) >>> 0];

			size = right - left;

			d++;

		} while (true);

	},

	next: function(obj, wrap = false){

		var list = this;

		if (list == null) {

			return null;

		}

		var i = list.indexOf(obj);

		if (i > -1) {

			return (wrap && i >= (list.length - 1)) ? list[0] : list[i + 1];

		}

		return null;

	},

	prev: function(obj, wrap = false){

		var list = this;

		if (list == null) {

			return null;

		}

		var i = list.indexOf(obj);

		if (i > 0) {

			return wrap ? list[list.length - 1] : list[i - 1];

		}

		return null;

	},

	get: function(slot, defaultVal){

		var list = this;

		var val = list[slot];

		if (val == null) {

			return defaultVal;

		}

		return val;

	},

	none:null

};

// register funcs

UB.registerFuncs(Array.prototype, arrayFuncs);